import { _decorator, Button, Component, Label, Node, Prefab, Tween, tween,instantiate,
     Vec3,input,Input} from 'cc';
const { ccclass, property } = _decorator;

@ccclass('Game')
export class Game extends Component {
    // 抽奖框节点
    @property({type:Node})
    private run1:Node = null;
    // 倒计时节点
    @property({type:Label})
    private Timer:Label = null;
    // 倒计时背景节点，用于控制倒计时显示与隐藏
    @property({type:Node})
    private TimerBg:Node = null;
    // 滑块节点，用于滑动金币倍率来让玩家选择投入金币的数量
    @property({type:Node})
    private Slider:Node = null;
    // 九宫格奖品预制体节点
    @property({type:Prefab})
    private block0:Prefab = null;
    @property({type:Prefab})
    private block1:Prefab = null;
    @property({type:Prefab})
    private block2:Prefab = null;
    @property({type:Prefab})
    private block3:Prefab = null;
    @property({type:Prefab})
    private block4:Prefab = null;
    @property({type:Prefab})
    private block5:Prefab = null;
    @property({type:Prefab})
    private block6:Prefab = null;
    @property({type:Prefab})
    private block7:Prefab = null;
    // 金币预制体，放置于玩家投入金币格子内，提高观赏性
    @property({type:Prefab})
    private GoldCoin:Prefab = null;
    // 金币挂载节点
    @property({type:Node})
    private GoldCoinNode:Node = null;
    // 开奖记录节点，用于展示抽奖结果
    @property({type:Node})
    private recordArrs:Node = null;
    // 玩家持有金币数量节点
    @property({type:Label})
    private playerCoinNode:Label = null;
    // 显示玩家投入金币数量节点
    @property({type:Label})
    private playerInputCoin0:Label = null;
    @property({type:Label})
    private playerInputCoin1:Label = null;
    @property({type:Label})
    private playerInputCoin2:Label = null;
    @property({type:Label})
    private playerInputCoin3:Label = null;
    @property({type:Label})
    private playerInputCoin4:Label = null;
    @property({type:Label})
    private playerInputCoin5:Label = null;
    @property({type:Label})
    private playerInputCoin6:Label = null;
    @property({type:Label})
    private playerInputCoin7:Label = null;
    // 托管按钮背景1
    @property({type:Node})
    private autoPlayStart:Node = null;
    // 托管按钮背景2
    @property({type:Node})
    private autoPlayShut:Node = null;


    // @property({type:Button})
    // private test:Button = null;

    // 储存8个格子的坐标，方便后续设置缓动
    private positions = [
            new Vec3(110, -110, 0),
            new Vec3(0, -110, 0),
            new Vec3(-110, -110, 0),
            new Vec3(-110, 0, 0),
            new Vec3(-110, 110, 0),
            new Vec3(0, 110, 0),
            new Vec3(110, 110, 0),
            new Vec3(110, 0, 0)
        ];
    // 抽奖框缓动
    private tween1:Tween;
    // 滑块是否正在缓动，防止玩家多次点击
    private istween2 = false;
    // 滑块缓动
    private tween2:Tween;
    // 倒计时时长
    private score = 10
    // 定时器ID
    private timer:number = null;
    // 设置金币数量向上移动极限次数，初始为2
    private upNum = 2
    // 设置金币数量向下移动极限次数，初始为1
    private downNum = 1
    // 玩家选择的投入金币数量,初始为1000(可通过向上或向下的次数来获取数量)
    private coinNum = 1000
    // 玩家持有金币数量，初始100000
    private playerCoin = 100000
    // 玩家投入金币格子数组
    private InputGridArr = []
    // 通过控制该值达到轮盘转动时玩家无法投入金币功能,true为允许false为禁止
    private PlayerInput = true
    // 玩家最大投入格子个数，超过则无法继续投入，最大为6
    private playerInputNums = 0
    // 玩家每个格子投入次数数组
    private playerInputNumsArr = [0,0,0,0,0,0,0,0]
    // 玩家每次游戏在每个格子投入金币的数量数组
    private InputCoinArr = [,,,,,,,]
    // 玩家本次抽奖获得金币收入
    private playerIncome = 0
    // 是否开启托管
    private isAutoPlay = false
    // 自动投入金币次数，大于1则不会继续投入
    private isAutoInput = 0
    // 记录玩家上一轮每个格子投入次数数组情况
    private lastplayerInputNumsArr = [0,0,0,0,0,0,0,0]
    // 记录玩家上一轮投入金币数量
    private lastInputCoinArr = [,,,,,,,]
    // 记录玩家上一轮投入金币格子个数
    private lastInputNums = 0
    // 玩家每轮的点击次数，用于判断是否有进行投币活动
    private playerClickNum = 0
    start() {
        // 启动常驻抽奖框运动
        this.offenRun()
        // 开启倒计时抽奖
        this.Draw()
        // 隐藏所有展示金币投入数量节点
        // this.HideCoin()
        // 隐藏托管按钮背景1(未开启托管)
        this.autoPlayStart.active = false
        // 展示托管按钮背景2(未开启托管)
        this.autoPlayShut.active = true

    }
    // 统一设置所以展示投入金币数量设置为空
    HideCoin(){
        // this.InputCoinArr = [,,,,,,,]
        for(var i = 0 ;i < this.GoldCoinNode.children.length ;i++){
            this.GoldCoinNode.children[i].destroy()
        }
        this.InputGridArr = []
        this.playerInputCoin0.string = "" 
        this.playerInputCoin1.string = "" 
        this.playerInputCoin2.string = "" 
        this.playerInputCoin3.string = "" 
        this.playerInputCoin4.string = "" 
        this.playerInputCoin5.string = "" 
        this.playerInputCoin6.string = "" 
        this.playerInputCoin7.string = "" 
    }
    // 常驻抽奖框运动
    offenRun(){
        // 如果开启自动投入，则把玩家上一轮投入金币次数以及投入金币数量赋值给当前轮
        if(this.isAutoPlay){
            this.playerInputNumsArr = this.lastplayerInputNumsArr
            this.InputCoinArr = this.lastInputCoinArr
            this.playerInputNums = this.lastInputNums
        }else{// 否则初始化将上轮金币清空，重新开始游戏
            this.playerInputNumsArr = [0,0,0,0,0,0,0,0]
            this.InputCoinArr = [,,,,,,,]
            this.playerInputNums = 0
        }

        // 托管模式
        // 等待.5秒再自动投入金币，让玩家更直观看到自动投入
        setTimeout(()=>{
            this.AutoPlay()
        },500)

        // 通过FirstGrid函数获取转动的首个格子
        let StartNum = this.FirstGrid()
        // 通过获取点击开始抽奖按钮时抽奖框位置获取转动顺序
        const pos1 = this.positions.slice(0,StartNum)
        const pos2 = this.positions.slice(StartNum,8)
        // 将pos1和pos2俩个数组结合得到抽奖框的移动顺序
        pos2.push(...pos1)
        // 设置缓动
        this.tween1 = tween(this.run1);
        // 每个格子添加缓动效果
        pos2.forEach(pos => {
            // 设置缓动运动时间为0同时设置延时效果来达到转动效果
            this.tween1 = this.tween1.to(0, {position: pos}).delay(1);
        });
        this.tween1.union().repeat(Infinity).start();
    }
    // 获取下次转动的第一个格子
    FirstGrid(){
        // 下次开始转动的第一个格子
        let StartNum = 0
        for(var i = 0 ;i < 8 ;i++){
            // 当抽奖框和某个格子的xyz坐标都相等时，则该格子是起始格
            if(this.run1.position.x == this.positions[i].x &&
                 this.run1.position.y == this.positions[i].y &&
                  this.run1.position.z == this.positions[i].z){
                // 赋值
                StartNum = i
                // console.log(this.run1.position,"run1")
            }
        }
        // 返回首个转动格子
        return StartNum
    }
    // 控制抽奖框停止低倍率的方格
    ctrlGrid(randomNumber){
        // 0-90都是x5倍率，90-95是x10倍率，95-98是x15倍率，
        // 98-100是x25倍率，x45倍率概率为0
        if(randomNumber <= 20){
            randomNumber = 2
        }else if(randomNumber <= 40 && randomNumber > 20){
            randomNumber = 3
        }else if(randomNumber <= 60 && randomNumber > 40){
            randomNumber = 4
        }else if(randomNumber <= 80 && randomNumber > 60){
            randomNumber = 5
        }else if(randomNumber <= 90 && randomNumber > 80){
            randomNumber = 1
        }else if(randomNumber <= 95 && randomNumber > 90){
            randomNumber = 0
        }else if(randomNumber <= 99 && randomNumber > 95){
            randomNumber = 7
        }else{
            randomNumber = 6
        }
        // 返回停止格子位置(0-7的顺序是由右中棕色格子顺时针数起)
        return randomNumber
    }
    // 进行抽奖
    run(){
        this.tween1.stop()
        // 禁止玩家投入金币
        this.PlayerInput = false
        // 每次开始都会随机一个数字来决定最终停下的格子
        // 生成 1-8 的随机整数
        // const randomNumber = Math.floor(Math.random() * 8) + 1;

        // 生成 1-100 的随机整数
        const randomNumber = Math.floor(Math.random() * 100) + 1;
        // 控制抽奖框停止低倍率的方格
        let stopNum = this.ctrlGrid(randomNumber)
        // console.log(randomNumber)
        console.log(stopNum,"stopNum")
        // 通过FirstGrid函数获取转动的首个格子
        let StartNum = this.FirstGrid()
        // 通过获取点击开始抽奖按钮时抽奖框位置获取转动顺序
        const pos1 = this.positions.slice(0,StartNum)
        const pos2 = this.positions.slice(StartNum,8)
        // 将pos1和pos2俩个数组结合得到抽奖框的移动顺序
        pos2.push(...pos1)
        // 设置缓动
        this.tween1 = tween(this.run1);
        // 每个格子添加缓动效果
        pos2.forEach(pos => {
            // 设置缓动运动时间为0同时设置延时效果来达到转动效果
            this.tween1.to(0, {position: pos}).delay(0.1);
        });
        this.tween1.union().repeat(4)
        // 转完规定圈数后，方框继续移动回初始启动，便于控制最终停止格子
        this.positions.slice(StartNum,8).forEach(pos => {
            // 设置缓动运动时间为0同时设置延时效果来达到转动效果
            this.tween1.to(0, {position: pos}).delay(.1);
        });

        // 设置最终停下格子的数组
        const positions2 = this.positions.slice(0,stopNum)
        // 部分格子添加缓动效果
        positions2.forEach(pos => {
            // 设置缓动运动时间为0同时设置延时效果来达到转动效果
            this.tween1 = this.tween1.to(0, {position: pos}).delay(0.1);
        });
        
        this.tween1.start();

        // 当抽奖结束后5秒重新开始常驻缓慢转动
        // 开始抽奖倒计时倒计时
        setTimeout(() => {
            // 停止缓动
            this.tween1.stop()
            // 将奖品公布于开奖记录
            this.showRecord(stopNum)
            // 倒计时抽奖
            this.Draw()
            // 将玩家赢得的金币添加至余额
            this.playerIncomeF(stopNum)
            // 隐藏上一轮玩家投入金币格子，并清空上一轮投入金币数量数组
            this.HideCoin()
            // 重置玩家可投入金币格子数量
            this.playerInputNums = 0
            // 重置每个格子的点击次数数组
            this.playerInputNumsArr = [0,0,0,0,0,0,0,0]
            // 重置每个格子投入金币数量数组
            this.InputCoinArr = [,,,,,,,]
            // 允许玩家进行下一次投入金币
            this.PlayerInput = true
            // 重置自动投入金币次数
            this.isAutoInput = 0
            // 重置玩家每轮的点击次数
            this.playerClickNum = 0
            // 每次游戏开始前把玩家上一局的收入归0
            this.playerIncome = 0
            // 开启常驻缓慢转动
            this.offenRun()
        }, 5000);
    }
    // 倒计时结束进行抽奖
    Draw(){
        this.TimerBg.active = true
        clearInterval(this.timer)
        // 重新设置倒计时的时长
        this.score = 10
        this.Timer.string = this.score.toString()
        // 通过setTimeOut减去第一次倒计时，否则需要等待SetInterval启动的1秒
        setTimeout(()=>{
            this.score-=1
            // 通过setInterval反复减少时间实现定时器效果
            this.timer = setInterval(()=>{
            // 当倒计时归0时开始抽奖并消除当前定时器
            if(this.score==0){
                // 消除当前计时器
                clearInterval(this.timer)
                // 隐藏倒计时背景
                this.TimerBg.active = false
                // 开始抽奖
                this.run()
            }
            // 设置倒计时显示的时间
            this.Timer.string = this.score.toString()
            this.score--
        },1000)
        })
    }
    // 向上移动110像素
    upSlider(){
        // 如果滑块正在移动，无法继续点击
        if(this.istween2)return
        this.istween2 = true
        // 设置向上移动极限次数
        if(this.upNum == 0){
            return
        }
        this.tween2 = tween(this.Slider)
        this.tween2 = this.tween2.to(.5,{position:new Vec3(0,this.Slider.position.y+110,0)})
        // 向上移动次数减一，向下移动次数加一
        this.downNum += 1
        this.upNum -= 1
        this.tween2.start()
        // 修改投入金币数量
        this.getInput()
        setTimeout(()=>{
            this.istween2 = false
        },800)
    }
    // 向下移动110像素
    downSlider(){
        // 如果滑块正在移动，无法继续点击
        if(this.istween2)return
        this.istween2 = true
        // 设置向下移动极限次数
        if(this.downNum == 0){
            return
        }
        this.tween2 = tween(this.Slider)
        this.tween2 = this.tween2.to(.5,{position:new Vec3(0,this.Slider.position.y-110,0)})
        // 向下移动次数减一，向上移动次数加一
        this.downNum -= 1
        this.upNum += 1
        this.tween2.start()
        // 修改投入金币数量
        this.getInput()
        setTimeout(()=>{
            this.istween2 = false
        },800)
    }

    // 制作宝箱预制体，放置与开奖记录内展示
    showRecord(stopNum){
        // 定义一个奖品
        let block = null
        // 通过最终停下的格子来决定该奖品是什么
        // 0->1奖品(x15) 1->2奖品(x10) 2->3奖品(x5) 3->4奖品(x5) 
        // 4->5奖品(x5) 5->6奖品(x5) 6->7奖品(x45) 7->8奖品(x25) 
        if(stopNum==0){
            // 实例化预制体节点
            block = instantiate(this.block0);
        }else if(stopNum==1){
            block = instantiate(this.block1);
        }else if(stopNum==2){
            block = instantiate(this.block2);
        }else if(stopNum==3){
            block = instantiate(this.block3);
        }else if(stopNum==4){
            block = instantiate(this.block4);
        }else if(stopNum==5){
            block = instantiate(this.block5);
        }else if(stopNum==6){
            block = instantiate(this.block6);
        }else{
            block = instantiate(this.block7);
        }
        // 将生成好的预制体节点挂载到开奖记录数组上，便于展示
        this.recordArrs.addChild(block)
        // 播放宝箱开启动画
        // this.playChestOpenAnimation(block);
        
        // 通过for循环为奖品数组所有奖品设置新的位置，最新的奖品在最上方，其余依次往下移动
        for(var i = this.recordArrs.children.length-1; i >= 0 ; i--){
            this.recordArrs.children[i].setPosition(new Vec3(0,-110 * (this.recordArrs.children.length - i - 1),0))
            // 当奖品展示超过开奖记录，则删除该预制体节点
            if(this.recordArrs.children[i].position.y<=-330){
                this.recordArrs.children[i].destroy()
            }
        }
    }
    // 获取玩家选择投入金币数量
    getInput(){
        // 通过查看当前可向上次数来判断当时选择投入金币数量(使用向下次数判断亦可)
        let CoinNums = 0
        if(this.upNum == 0){
            CoinNums = 100000
        }else if(this.upNum == 1){
            CoinNums = 10000
        }else if(this.upNum == 2){
            CoinNums = 1000
        }else{
            CoinNums = 500
        }
        // 修改投入金币数量
        this.coinNum = CoinNums
    }
    // 通过点击进行投入金币参与抽奖
    // 通过获取点击的按钮位置来确定玩家选择的是多少倍率的按钮,并获取投入次数
    InputCoin(e){
        // 如果玩家投入值为False,则玩家禁止投入金币
        if(!this.PlayerInput)return
        // 玩家金币数量小于投入金币数量时return
        if(this.playerCoin - this.coinNum < 0)return
        // 超出玩家可以投入格子数量时return
        // 玩家每轮的点击次数加1,用于检测Auto是否继承于上一轮，而不是游玩时开启的Auto
        this.playerClickNum += 1
        for(var i = 0 ;i < 8 ;i++){
            // 当抽奖框和某个格子的xyz坐标都相等时，则获取该格子编号以便后续计算玩家获取金币数量
            if(e.target._lpos.x == this.positions[i].x &&
                 e.target._lpos.y == this.positions[i].y &&
                  e.target._lpos.z == this.positions[i].z){
                // 将玩家点击的格子号码全部加入投入格子数组
                // 当i为7时添加0进入数组，与停止数统一，以防乱了顺序
                if(i==7){
                    if(this.playerInputNums>=6 && this.playerInputNumsArr[0] <= 0)break
                    // 将投入金币的格子编号添加至数组内
                    this.InputGridArr.push(0)
                    // 通过函数增加点击格子的点击次数，以及统计投入金币格子的个数
                    this.playerInputNumF(0)
                    // 玩家投入金币后展示投入数量在投入格子上方
                    this.showInputCoin(0)
                    // 每次选择投入金币后，触发更改金币数量方法，扣除相应数量金币
                    this.changeCoin(-this.coinNum)
                    
                    continue
                }
                if(this.playerInputNums>=6 && this.playerInputNumsArr[i + 1] <= 0)break
                this.InputGridArr.push(i+1)
                this.playerInputNumF(i+1)
                this.showInputCoin(i+1)
                // 每次选择投入金币后，触发更改金币数量方法，扣除相应数量金币
                this.changeCoin(-this.coinNum)
            }
        }
    }
    // 通过获取点击按钮的位置确认需要展示的金币框
    showInputCoin(num){
        // 如果玩家投入金币数量为空，则将其值设置为当前所选投入金币数量
        if(this.InputCoinArr[num] == null){
            this.InputCoinArr[num] = this.coinNum
        }else{
            this.InputCoinArr[num] += this.coinNum
        }
        // console.log(this.InputCoinArr[num],"InputCoinArr[num]")
        if(num == 0){
            this.playerInputCoin0.string = this.InputCoinArr[num].toString() 
        }else if(num == 1){
            this.playerInputCoin1.string = this.InputCoinArr[num].toString()
        }else if(num == 2){
            this.playerInputCoin2.string = this.InputCoinArr[num].toString()
        }else if(num == 3){
            this.playerInputCoin3.string = this.InputCoinArr[num].toString()
        }else if(num == 4){
            this.playerInputCoin4.string = this.InputCoinArr[num].toString()
        }else if(num == 5){
            this.playerInputCoin5.string = this.InputCoinArr[num].toString()
        }else if(num == 6){
            this.playerInputCoin6.string = this.InputCoinArr[num].toString()
        }else{
            this.playerInputCoin7.string = this.InputCoinArr[num].toString()
        }
        if(num > 0){
            num -= 1
        }else{
            num = 7
        }
        // console.log(num)
        let GoldCoins = null;
        GoldCoins = instantiate(this.GoldCoin)
        // 将金币预制体添加到挂载节点
        this.GoldCoinNode.addChild(GoldCoins)
        GoldCoins.setPosition(new Vec3(this.positions[num].x -35,this.positions[num].y - 30,0))
        // console.log(GoldCoins)
        
    }
    // 计算每个格子玩家投入次数
    playerInputNumF(num){
        // 每格子每点击一次，点击次数加1
        this.playerInputNumsArr[num]+=1
        // 当首次点击某个格子时，玩家投入格子数加1，最大为6,超过6无法继续投入金币
        if(this.playerInputNumsArr[num]==1){this.playerInputNums += 1}
    }
    // 抽奖结束，计算玩家获得金币数量,并更改金币数量，以及提示玩家获取金币数量
    playerIncomeF(stopNum){
        // 本轮游戏结束，记录玩家金币投入次数以及投入数量，便于下一轮自动投入
        // 记录玩家每个格子投入金币数量,只有玩家本轮游戏有投入金币，才会记录
        if(this.playerInputNums != 0){
            this.lastInputCoinArr = this.InputCoinArr
            // 记录玩家每个格子投入金币次数
            this.lastplayerInputNumsArr = this.playerInputNumsArr
            // 记录玩家投入金币次数，最大为6
            this.lastInputNums = this.playerInputNums
        }
        // console.log(this.playerInputNumsArr,"test")
        console.log(this.lastInputNums,"抽奖结束")
        for(var i = 0 ; i < 8; i++){
            if(this.InputCoinArr[i] == null){
                continue
            }
            // 如果玩家投入金币格子不是最终停下的格子，则不会获得金币
            if(stopNum != i)continue
            // 玩家收入等于投入金币数量*投入格子的金币倍数
            if(i==0){
                // 玩家收入 = 投入金币数量*投入次数*15倍率
                this.playerIncome += this.InputCoinArr[i] * 15
            }else if(i==1){
                // 玩家收入 = 投入金币数量*投入次数*10倍率
                this.playerIncome += this.InputCoinArr[i] * 10
            }else if(i==6){
                // 玩家收入 = 投入金币数量*投入次数*45倍率
                this.playerIncome += this.InputCoinArr[i] * 45
            }else if(i==7){
                // 玩家收入 = 投入金币数量*投入次数*25倍率
                this.playerIncome += this.InputCoinArr[i] * 25
            }else{
                // 玩家收入 = 投入金币数量*投入次数*5倍率
                this.playerIncome += this.InputCoinArr[i] * 5
            }
            // console.log(this.InputCoinArr)
        }
        // 触发修改金币函数
        this.changeCoin(this.playerIncome)
        console.log(this.playerIncome,"本轮玩家赚得金币")
    }
    // 修改玩家拥有金币数量
    changeCoin(num){
        // 玩家收入
        if(num>=0){
            for(var i = 0; i < 8; i++){
                if(i==0){
                    this.playerInputNumsArr[i]
                }
            }
            this.playerCoin += num
            this.playerCoinNode.string = this.playerCoin.toString()
        }else{//玩家支出
            this.playerCoin += num
            // 根据玩家持有金币数量修改
            this.playerCoinNode.string = this.playerCoin.toString()
        }
        
    }
    // 粘贴与增加投入金币数量
    CopyAddCoin(num){
        if(num == 0){
            this.playerInputCoin0.string = this.InputCoinArr[num].toString() 
        }else if(num == 1){
            this.playerInputCoin1.string = this.InputCoinArr[num].toString()
        }else if(num == 2){
            this.playerInputCoin2.string = this.InputCoinArr[num].toString()
        }else if(num == 3){
            this.playerInputCoin3.string = this.InputCoinArr[num].toString()
        }else if(num == 4){
            this.playerInputCoin4.string = this.InputCoinArr[num].toString()
        }else if(num == 5){
            this.playerInputCoin5.string = this.InputCoinArr[num].toString()
        }else if(num == 6){
            this.playerInputCoin6.string = this.InputCoinArr[num].toString()
        }else{
            this.playerInputCoin7.string = this.InputCoinArr[num].toString()
        }
        if(num > 0){
            num -= 1
        }else{
            num = 7
        }
        // console.log(num)
        let GoldCoins = null;
        GoldCoins = instantiate(this.GoldCoin)
        // 将金币预制体添加到挂载节点
        this.GoldCoinNode.addChild(GoldCoins)
        GoldCoins.setPosition(new Vec3(this.positions[num].x -35,this.positions[num].y - 30,0))
        // console.log(GoldCoins)
    }
    // 托管功能，记录玩家上一轮投入金币情况，下一轮自动投入
    AutoPlay(){
        // 若无上一轮数据，则return
        if(this.lastInputNums == 0)return


        // 如果自动投入次数大于一，则不会继续投入
        if(this.isAutoInput >= 1){
            return
        }
        
        // 如果玩家上一轮游戏没有投入任何一个格子，或者上一轮数据保存超过俩次，则清空数据
        // if(this.lastInputNums == 0){
        //     this.lastInputCoinArr = [,,,,,,,]
        //     this.lastplayerInputNumsArr = [0,0,0,0,0,0,0,0]
        //     this.lastInputNums = 0
        //     return
        // }
        // 如果玩家没有选择托管，则无法进行托管
        if(!this.isAutoPlay)return
        // 如果玩家选择托管，则根据玩家上一轮投入金币情况，自动投入金币
       // 复刻玩家上一轮金币投入数量
    //    this.InputCoinArr = this.lastInputCoinArr
       // 复刻玩家每个格子投入金币次数
    //    this.playerInputNumsArr =  this.lastplayerInputNumsArr
       // 复刻玩家投入金币次数，最大为6
    //    this.playerInputNums = this.lastInputNums
        // 遍历玩家投入金币数量，并进行投入
        // console.log(this.InputCoinArr,"InputCoinArr")
        if(this.playerInputNums == 0 || this.playerClickNum == 0){
            // 如果玩家本轮游戏没有投入任何格子，则将上一轮投入金币次数以及投入金币数量赋值给当前轮
            this.playerInputNumsArr = this.lastplayerInputNumsArr
            this.InputCoinArr = this.lastInputCoinArr
            this.playerInputNums = this.lastInputNums
            // 自动投币次数加一，最高为一
            this.isAutoInput += 1
            // 玩家选择投币格子次数加一最高为六
            this.playerInputNums += 1
            for(var i = 0; i < 8; i++){
                if(this.InputCoinArr[i] == null){
                    continue
                }
                
                // 自动投币次数加一，最高为一
                this.isAutoInput += 1
                // 更新数据
                this.CopyAddCoin(i)
                this.changeCoin(-this.InputCoinArr[i])
            }
        }else{
            // 如果玩家本轮游戏有投入任意格子，则将上一轮数据与本轮数据进行对比，增加与复制
            for(var i = 0; i < 8; i++){
                if(this.InputCoinArr[i] == null && this.lastInputCoinArr[i] == null){
                    continue
                }
                else if(this.InputCoinArr[i] == null && this.lastInputCoinArr[i] != null){
                    // 本轮新添加的投入格子，增加一个格子数
                    this.playerInputNums += 1
                    console.log(this.playerInputNums,"auto")
                    // 如果添加后玩家投入格子数大于6，则不添加数据
                    if(this.playerInputNums > 6)break
                    this.InputCoinArr[i] = this.lastInputCoinArr[i]
                    this.playerInputNumsArr[i] = this.lastplayerInputNumsArr[i]
                }
                else if(this.InputCoinArr[i] != null && this.lastInputCoinArr[i] == null){
                    this.InputCoinArr[i] += 0
                    this.playerInputNumsArr[i] += 0
                }
                else if(this.InputCoinArr[i] != null && this.lastInputCoinArr[i] != null){
                    this.InputCoinArr[i] += this.lastInputCoinArr[i]
                    this.playerInputNumsArr[i] += this.lastplayerInputNumsArr[i]
                    
                }
                // 自动投币次数加一，最高为一
                this.isAutoInput += 1
                // 更新数据
                this.CopyAddCoin(i)
                this.changeCoin(-this.InputCoinArr[i])
                
            }
        }
        
    }
    // 通过按钮启动托管
    isAuto(){
        // 所有设置再次触发都会变为相反的值,即开启Auto时触发会关闭Auto
        if(!this.isAutoPlay){
            this.isAutoPlay = true
        }else{
            this.isAutoPlay = false
        }
        if(this.autoPlayStart.active){
            this.autoPlayStart.active = false
        }else{
            this.autoPlayStart.active = true
        }
        if(this.autoPlayShut.active){
            this.autoPlayShut.active = false
        }else{
            this.autoPlayShut.active = true
        }
        // 点击触发自动模式
        this.AutoPlay()
    }
}


